#ifndef VECTORT_H
#define VECTORT_H

/*!
 *  \class Vectort
 *  \brief Représente un vecteur dans son sens mathématique
 *         Utilisation de template pour permettre de travailler avec n'importe quel type de donnée
 */

template <class T>

class VectorT
{
    public :

    /***********************************************************************/
    /*                      Properties                                     */
    /***********************************************************************/

    T * coordinates;	/*!< Coordonnées en x/y/z/w pouvant être utilisées pour définir un sommet, vecteur, normale etc	*/
    short dimension;    /*!< Nombre de coordonnées utilisées (x,y,z = 3)	*/

    /***********************************************************************/
    /*                      Constructors                                   */
    /***********************************************************************/

    /*!
     *      \fn Vectort()
     *      \brief Initialise un vecteur de dimension 3 à 0 : (0, 0, 0)
     */

    VectorT();

    /*!
     *      \fn Vectort()
     *      \brief Initialise un vecteur de dimension 1
     */

    VectorT(T aX);

    /*!
     *      \fn Vectort()
     *      \brief Initialise un vecteur de dimension 2
     */

    VectorT(T aX, T aY);

    /*!
     *      \fn Vectort()
     *      \brief Initialise un vecteur de dimension 3
     */

    VectorT(T aX, T aY, T aZ);

    /*!
     *      \fn Vectort()
     *      \brief Initialise un vecteur de dimension 4
     */

    VectorT(T aX, T aY, T aZ, T aW);

    VectorT(T * aCoordinates, short aDimension);

    VectorT(const Vectorf &);	/*!<	Constructeur par recopie	*/

    void InitArray(T * aCoordinates);

    /***********************************************************************/
    /*                      Surcharge d'opérateur                          */
    /***********************************************************************/

    /*!
     *  \fn Opérateur de recopie
     */

    VectorT & operator=(const Vectorf &);


    VectorT operator+(const Vectorf &); 	/*! Addition de 2 vecteurs */
    VectorT & operator+=(const Vectorf &);

    VectorT operator-(const Vectorf &); 	//  Soustraction de 2 vecteurs

    VectorT operator*(const Vectorf &); 	//  Multiplication de 2 vecteurs
    VectorT operator*(T val);        	//  Multiplication d'un vecteur et d'un nombre scalaire
    VectorT operator/(T val);           /*!< Division entre un vecteur et un nombre scalaire */

  //  bool operator ==(const Vectorf &);
  //  * */

    /***********************************************************************/
    /*                      Méthodes                                       */
    /***********************************************************************/

    T x();
    T y();
    T z();
    T w();

    void x(T aX);
    void y(T aY);
    void z(T aZ);
    void w(T aW);

        static float ProduitScalaire(Vectorf u, Vectorf v);       //  Calcul le produit scalaire des vecteurs u et v
        static Vectorf IntersectionPlan(Vectorf u, Vectorf lineVertex, Vectorf normalPlane, Vectorf planeVertex);

        float * Array();
        float Norme();          //  Calcul la norme du vecteur qui correspond à la distance que ce dernier parcours

        Vectorf Normalize();
        void Print();
        Vectorf Inverse();

        static Vectorf  ProduitVectoriel(Vectorf u, Vectorf v);


        /*
        void Set(float x, float y, float z);	//	Méthode définissant les 3 composantes du vecteur
        void Set(float * aF);

        float * ToArray();			//	Méthode retournant un tableau contenant les coordoonnées du vecteur

   * int Collide(Vectorf);  */// Détermine si les 2 sommets sont suffisament proche via une valeur r (rayon)

        /***********************************************************************/
        /*                      Méthodes statiques                             */
        /***********************************************************************/
/*
        static float Angle(Vectorf u, Vectorf v);                 //  Calcul l'angle entre les vecteurs u et v
        static Vectorf & CalculVecteur(Vectorf A, Vectorf B);    //  Calcul la valeur du vecteur entre les points A et B

        static Vectorf & ProduitVectoriel(Vectorf u, Vectorf v); //  Calcul le produit vectoriel des vecteurs u et v

         // Algo qui permet de déterminer si les droites AB et CD se coupent
        static bool Intersection(Vectorf A, Vectorf B,Vectorf C, Vectorf D, Vectorf * aResultat);
};

class Vector3uc	//	Vecteur de unsigned char (compris entre 0 et 255), utilisable pour coder les couleurs
{
    public :

            unsigned char x;
            unsigned char y;
            unsigned char z;

            Vector3uc();
            Vector3uc(unsigned char argX, unsigned char argY, unsigned char argZ);

            Vector3uc & operator+(const Vector3uc &);
            Vector3uc & operator-(const Vector3uc &);
            Vector3uc & operator=(const Vector3uc &);
};
*/


};

#endif // VECTORT_H
